/** ==================================================================================== **/
/** 					 GESTIONE CONTROLLI COSTRUTTORE : ol.interactions				 **/
/** ==================================================================================== **/

/**
 * Service: olInteractionService 
 * 
 * Inherits from:
 *  - <ol.interaction>
 * 
 * Per interaction s'intendono le azioni degli utenti che modificano lo stato della mappa. Alcune interaction sono simili ai controlli,
 * ma non sono associati a un elemento DOM. 
 * Ad esempio, ol.interaction.KeyboardZoom è funzionalmente lo stesso di ol.control.Zoom, ma è innescata da un'evento di tastiera e non da un 
 * pulsante.
 * 
 * Uso:
 *  (code)
 *    var map = ...
 *    var interaction = olInteractionService.<nome_function>(<param>);
 *    map.addInteraction(interaction);
 *  (end)
 */
BootApplication.service("olInteractionService", [ 'log', '$translate', 'olStyleService', 'configuration', '$filter', 
                                                  function( log,  $translate, olStyleService, appConstants, $filter ) {
	
	/**
	 * Consente all'utente di ruotare la mappa cliccando e trascinando sulla mappa, di solito in combinazione con un ol.events.condition 
	 * quando i tasti Alt-Shift-drag rotate sono premuti.
	 * 
	 * Questa interazione è supportata solo per i dispositivi di mouse.
	 */
	this.altShiftDragRotate = function() {
		
		var dragRotate =  
				new ol.interaction.DragRotate({
					/** 
					 * Una funzione che prende un ol.MapBrowserEvent e restituisce un valore booleano che indica se l'evento deve essere gestito. 
					 * Il valore predefinito è ol.events.condition.altShiftKeysOnly.
					 */
					condition: ol.events.condition.altShiftKeysOnly,
					/** Animation duration in milliseconds. Default is 250. **/
					duration: 250,
					/** true if the interaction is active, false otherwise.  **/
					active: true
				});

		return dragRotate;
	}// close altShiftDragRotate
	
	/**
	 * Consente all'utente di ingrandire con un doppio click sulla mappa.
	 */
	this.doubleClickZoom = function(){
		
		var doubleClickZoom = 
				new ol.interaction.DoubleClickZoom({
					/** The zoom delta applied on each double click, default is 1. */
					delta: 1,
					/** Animation duration in milliseconds. Default is 250. **/
					duration: 250,
					/** true if the interaction is active, false otherwise.  **/
					active: true
				});
		
		return doubleClickZoom;
	}// close doubleClickZoom
	
	/**
	 * Consente all'utente di spostare la mappa con le frecce della tastiera. Si noti che, anche se questa interazione è per default inclusa nelle mappe, 
	 * i tasti possono essere utilizzati solo quando lo stato attivo è sull'elemento a cui sono fissati gli eventi di tastiera. 
	 * Per impostazione predefinita, questa è la mappa div, anche se è possibile cambiare questo "keyboardEventTarget" in ol.Map. 
	 */
	this.keyboardPan = function(){
		
		var keyboardPan = 
				new ol.interaction.KeyboardPan({
					/** 
					 * A function that takes an ol.MapBrowserEvent and returns a boolean to indicate whether that event should be handled. 
					 * Default is ol.events.condition.noModifierKeys and ol.events.condition.targetNotEditable. 
					 */
	//				condition: ,
					/** Animation duration in milliseconds. Default is 100. **/
					duration: 100,
					/** Pixel The amount to pan on each key press. Default is 128 pixels. **/
					pixelDelta: 128,
					/** true if the interaction is active, false otherwise.  **/
					active: true
				});
		
		return keyboardPan;
	}// close keyboardPan
	
	/**
	 * Consente all'utente di ingrandire la mappa utilizzando i tasti della tastiera + e -. 
	 * Si noti che, anche se questa interazione è per default inclusa nelle mappe, i tasti possono essere utilizzati solo quando lo stato attivo 
	 * è sull'elemento a cui sono fissati gli eventi di tastiera. 
	 * Per impostazione predefinita, questa è la mappa div, anche se è possibile cambiare questo con keyboardEventTarget in ol.Map. 
	 */
	this.keyboardZoom = function(){
		
		var keyboardZoom = 
				new ol.interaction.KeyboardZoom({
					/** 
					 * A function that takes an ol.MapBrowserEvent and returns a boolean to indicate whether that event should be handled. 
					 * Default is ol.events.condition.targetNotEditable.
					 */
					condition: ol.events.condition.targetNotEditable,
					/** Animation duration in milliseconds. Default is 100. **/
					duration: 100,
					/** The amount to zoom on each key press. Default is 1. **/
					delta: 1,
					/** true if the interaction is active, false otherwise.  **/
					active: true
				});
		
		return keyboardZoom;
	}// close keyboardZoom
	
	/**
	 * Consente all'utente di ingrandire la mappa facendo scorrere la rotellina del mouse.
	 */
	this.mouseWheelZoom = function(){
		
		var mouseWheelZoom =  
				new ol.interaction.MouseWheelZoom({
					/** Animation duration in milliseconds. Default is 250. **/
					duration: 250,
					/** true if the interaction is active, false otherwise.  **/
					active: true
				});
		
		return mouseWheelZoom;
	}// close mouseWheelZoom
	
	/**
	 * Consente all'utente di ingrandire la mappa cliccando e trascinando sulla mappa, di solito in combinazione con un ol.events.condition 
	 * quando il tasto, shift di default, viene tenuto premuto.
	 */
	this.shiftDragZoom = function(){
		
		var dragZoom = 
				new ol.interaction.DragZoom({
					/** 
					 * A function that takes an ol.MapBrowserEvent and returns a boolean to indicate whether that event should be handled. 
					 * Default is ol.events.condition.shiftKeyOnly.
					 */
					condition: ol.events.condition.shiftKeyOnly,
					/** Animation duration in milliseconds. Default is 200. **/
					duration: 200,
					/** Style for the box. **/
					style:
						new ol.style.Style({
							stroke: new ol.style.Stroke({
								color: [169, 68, 66, 1] /** colore rosso **/
					        })
					    }),
					/** true if the interaction is active, false otherwise.  **/
					active: true
			   });
		
		return dragZoom;
	}// shiftDragZoom
	
	/**
	 * Consente all'utente di scorrere la mappa trascinando la mappa.
	 */
	this.dragPan = function(){
		
		var dragPan =  
				new ol.interaction.DragPan({
					/** true if the interaction is active, false otherwise.  **/
					active: true
				});
		
		return dragPan;
	}// close dragPan
	
	/**
	 * Consente all'utente di ruotare la mappa ruotando con due dita su un touch screen. 
	 */
	this.pinchRotate = function(){
		
		var pinchRotate = 
				new ol.interaction.PinchRotate({
					/** The duration of the animation in milliseconds. Default is 250. **/
					duration: 250,
					/** Minimal angle in radians to start a rotation. Default is 0.3. **/
					threshold: 0.3,
					/** true if the interaction is active, false otherwise.  **/
					active: true
				});
		
		return pinchRotate;
	}// close pinchRotate
	
	/**
	 * Consente all'utente di ingrandire la mappa pizzicando con due dita su un touch screen.
	 */
	this.pinchZoom = function(){
		
		var pinchZoom = 
				new ol.interaction.PinchZoom({
					/** Animation duration in milliseconds. Default is 400. **/
					duration: 400,
					/** true if the interaction is active, false otherwise.  **/
					active: true
				});
		
		return pinchZoom;
	}// close pinchZoom

	/**
	 * Ritorna lo strumento di disegno appositamente configurato per tracciare linee su mappa.
	 * "ngeo" mette a disposizione un'Interaction dedicata per misurare la lunghezza.
	 * 
	 * Returns:  
	 * 	  {@link ngeo.interaction.MeasureLength} 
	 */
	this.createNgeoMeasureLengthInteraction = function (){
		
		/**
		 * Creo gli elementi HTML per i tooltip degli strumenti di misura.
		 */ 
		var measureStartMsg = angular.element("<span>" +  $translate.instant("OpenLayers.olMeasure.helpMsg") + "</span>");
		var measureLengthContinueMsg = angular.element("<span>" + $translate.instant("OpenLayers.olMeasure.continueLineMsg") + "</span>");
		  
		/*
		 * @typedef {
		 *   format: (ngeox.unitPrefix),
		 *   {
		 *    decimals: (number|undefined),
		 *    displayHelpTooltip: (boolean|undefined),
		 *    startMsg: (Element|undefined),
		 *    style: (ol.style.Style|Array.<ol.style.Style>|ol.style.StyleFunction|undefined),
		 *    sketchStyle: (ol.style.Style|Array.<ol.style.Style>|ol.style.StyleFunction|undefined)
		 *   }
		 * }
		 */
		var measureLength = new ngeo.interaction.MeasureLength($filter('ngeoUnitPrefix'),{
			/**
			 * Stile della feature mentre la si disegna, quindi prima che venga catturato l'evento di "drawend".
			 */
		    sketchStyle: olStyleService.createSketchStyleFeatureMeasureLength(),
		    /**
		     * True o false a seconda se si vuole visualizzare o meno il tooltip
		     */
		    displayHelpTooltip: true,
		    /**
		     * Definisce il numero di decimali da mantenere nella misurazione. Se non è definito,
		     * Allora il comportamento di default si verifica a seconda del tipo di misura.
		     */
		    decimals: 3,
		    /**
		     * Il messaggio da visualizzare quando l'utente è in procinto di iniziare a disegnare.
		     */
		    startMsg: measureStartMsg[0],
		    /**
		     * Messaggio da mostrare dopo che il primo punto viene disegnato.
		     */
		    continueMsg: measureLengthContinueMsg[0]
		});
		
		measureLength.setActive(false);
		
		return measureLength;
	}// close createNgeoMeasureLengthInteraction
	
	/**
	 * Ritorna lo strumento di disegno appositamente configurato per tracciare l'area su mappa.
	 * "ngeo" mette a disposizione un'Interaction dedicata per misurare la superficie.
	 * 
	 * Returns:  
	 * 	  {@link ngeo.interaction.MeasureArea} 
	 */
	this.createNgeoMeasureAreaInteraction = function () {
		
		/**
		 * Creo gli elementi HTML per i tooltip degli strumenti di misura.
		 */ 
		var measureStartMsg = angular.element("<span>" +  $translate.instant("OpenLayers.olMeasure.helpMsg") + "</span>");
		var measureAreaContinueMsg = angular.element("<span>" + $translate.instant("OpenLayers.olMeasure.continueAreaMsg") + "</span>");
		  
		/*
		 * @typedef {
		 *   format: (ngeox.unitPrefix),
		 *   {
		 *    decimals: (number|undefined),
		 *    displayHelpTooltip: (boolean|undefined),
		 *    startMsg: (Element|undefined),
		 *    style: (ol.style.Style|Array.<ol.style.Style>|ol.style.StyleFunction|undefined),
		 *    sketchStyle: (ol.style.Style|Array.<ol.style.Style>|ol.style.StyleFunction|undefined)
		 *   }
		 * }
		 */
		var measureArea = new ngeo.interaction.MeasureArea($filter('ngeoUnitPrefix'),{
			/**
			 * Stile della feature mentre la si disegna, quindi prima che venga catturato l'evento di "drawend".
			 */
		    sketchStyle: olStyleService.createSketchStyleFeatureMeasureArea(),
		    /**
		     * True o false a seconda se si vuole visualizzare o meno il tooltip
		     */
		    displayHelpTooltip: true,
		    /**
		     * Definisce il numero di decimali da mantenere nella misurazione. Se non è definito,
		     * Allora il comportamento di default si verifica a seconda del tipo di misura.
		     */
		    decimals: 3,
		    /**
		     * Il messaggio da visualizzare quando l'utente è in procinto di iniziare a disegnare.
		     */
		    startMsg: measureStartMsg[0],
		    /**
		     * Messaggio da mostrare dopo che il primo punto viene disegnato.
		     */
		    continueMsg: measureAreaContinueMsg[0]
		});
		
		measureArea.setActive(false);
		
		return measureArea;
	}// close createNgeoMeasureAreaInteraction
	
	/**
	 * Ritorna lo strumento di disegno appositamente configurato per tracciare l'area su mappa.
	 * "ngeo" mette a disposizione un'Interaction dedicata per misurare l'angolo del cerchio tracciato e la lunghezza del diametro.
	 * 
	 * Returns:  
	 * 	  {@link ngeo.interaction.MeasureAzimut} 
	 */
	this.createNgeoMeasureAzimutInteraction = function () {
		
		/**
		 * Creo gli elementi HTML per i tooltip degli strumenti di misura.
		 */ 
		var measureStartMsg = angular.element("<span>" +  $translate.instant("OpenLayers.olMeasure.helpMsg") + "</span>");
		var measureAzimutContinueMsg = angular.element("<span>" + $translate.instant("OpenLayers.olMeasure.continueAzimutMsg") + "</span>");
		  
		/*
		 * @typedef {
		 *   format: (ngeox.unitPrefix),
		 *   {
		 *    decimals: (number|undefined),
		 *    displayHelpTooltip: (boolean|undefined),
		 *    startMsg: (Element|undefined),
		 *    style: (ol.style.Style|Array.<ol.style.Style>|ol.style.StyleFunction|undefined),
		 *    sketchStyle: (ol.style.Style|Array.<ol.style.Style>|ol.style.StyleFunction|undefined)
		 *   }
		 * }
		 */
		var measureAzimut = new ngeo.interaction.MeasureAzimut($filter('ngeoUnitPrefix'),{
			/**
			 * Stile della feature mentre la si disegna, quindi prima che venga catturato l'evento di "drawend".
			 */
		    sketchStyle: olStyleService.createSketchStyleFeatureMeasureAzimut(),
		    /**
		     * True o false a seconda se si vuole visualizzare o meno il tooltip
		     */
		    displayHelpTooltip: true,
		    /**
		     * Definisce il numero di decimali da mantenere nella misurazione. Se non è definito,
		     * Allora il comportamento di default si verifica a seconda del tipo di misura.
		     */
		    decimals: 3,
		    /**
		     * Il messaggio da visualizzare quando l'utente è in procinto di iniziare a disegnare.
		     */
		    startMsg: measureStartMsg[0],
		    /**
		     * Messaggio da mostrare dopo che il primo punto viene disegnato.
		     */
		    continueMsg: measureAzimutContinueMsg[0]
		});
		
		measureAzimut.setActive(false);
		
		return measureAzimut;
	}// close createNgeoMeasureAzimutInteraction
	
	/**
	 * Ritorna lo strumento di disegno appositamente configurato per disegnare geometrie del tipo fornito in ingresso
	 * su mappa.
	 * 
	 * @param {@link ol.source.Vector} destVector, layer di destinazione per le feature disegnate
	 * @param {@link String} drawingType, la tipologia di geometria per la quale è attiva l'interaction
	 * 
	 * Returns:  
	 * 	  {@link ol.interaction.Draw} 
	 */
	this.createDrawInteraction = function (destVector, drawingType) {
		 
		var draw = new ol.interaction.Draw({
				/** Identificativo interactio **/
			 	id: appConstants.getParam("ol.ApplicationProperty").ID_INTERACTION_DRAW_FEATURE,
				/** 
				 * collection di destinazione per le feature disegnate. 
				 */
				source: destVector,
				/** 
				 * Distanza di pixel per far scattare la fine del disegno 
				 */
				snapTolerance: 5,
				/** 
				 * Drawing type ('Point', 'LineString', 'Polygon', 'MultiPoint', 'MultiLineString', or 'MultiPolygon'). 
				 */
				type: drawingType,
				/** 
				 * Il numero di punti che deve essere disegnato prima che un poligono può essere finito. Il valore predefinito è 3. 
				 */
				minPointsPerRing: 3,
				/**
				 * Stile della feature mentre la si disegna, quindi prima che venga catturato l'evento di "drawend".
				 */
				style: olStyleService.createSketchStyleFeatureDraw(),
				/** 
				 * Geometry name to use for features created by the draw interaction. 
				 */
				geometryName: "featureDraw",
				/**
				 * Una funzione che prende un ol.MapBrowserEvent e restituisce un valore booleano che indica se l'evento deve essere gestito. 
				 * Di default è ol.events.condition.ModifierKeys (Return true if no modifier key (alt-, shift- or platform-modifier-key) è premuto.
				 * Aggiunge un vertice o disattiva disegno a mano libera.
				 */
				condition: ol.events.condition.ModifierKeys,
				/**
				 * Condizione che attiva disegno a mano libera per le linee e poligoni. Questa funzione prende un ol.MapBrowserEvent e 
				 * restituisce un valore booleano per indicare se tale evento deve essere gestito. 
				 * Il valore predefinito è ol.events.condition.shiftKeyOnly, il che significa che il tasto Shift attiva il disegno a mano libera.
				 * 
				 * NOTA:
				 *  - ol.events.condition.shiftKeyOnly : 
				 *  	Restituisce vero se solo viene premuto il tasto shift, false altrimenti (per esempio quando in aggiunta viene premuto 
				 *  	il tasto alt).
				 */
				freehandCondition: ol.events.condition.shiftKeyOnly
			});
			 
		 draw.setId(appConstants.getParam("ol.ApplicationProperty").ID_INTERACTION_DRAW_FEATURE);
		 /** true if the interaction is active, false otherwise. **/
		 draw.setActive(false);
		
		 return draw;
	}// close createDrawInteraction

	/**
	 * Ritorna lo strumento che gestisce la selezione dei dati vettoriali, appositamente configurato per la selezione delle
	 * feature prodotte dagli strumenti di edit .
	 * 
	 * @param {@link ol.layer.Vector} destVector, layer di destinazione
	 * 
	 * Returns:  
	 * 	  {@link ol.interaction.Select} 
	 */
	this.createSelectDrawInteraction = function (destVector) {
		
		/**
		 * Handles selection of vector data. A ol.FeatureOverlay is maintained internally to store the selected feature(s). 
		 * Which features are selected is determined by the condition option, and optionally the toggle or add/remove options.
		 */
		var select = new ol.interaction.Select({
				/** Identificativo interaction **/
			 	id: appConstants.getParam("ol.ApplicationProperty").ID_INTERACTION_SELECT_MODIFY_FEATURE,
			 	/**
			 	 * A list of layers from which features should be selected. Alternatively, a filter function can be provided. 
			 	 * The function will be called for each layer in the map and should return true for layers that you want to be selectable. 
			 	 * If the option is absent, all visible layers will be considered selectable.
			 	 */
				layers: [destVector],
				/**
				 * Un valore booleano che determina se il comportamento di default dovrebbe essere la selezione singola delle feature 
				 * o anche più di una. Il valore predefinito è falso i.e select singola.
				 */
				multi: false
			});
		
		select.setId(appConstants.getParam("ol.ApplicationProperty").ID_INTERACTION_SELECT_MODIFY_FEATURE);
		/** true if the interaction is active, false otherwise. **/
		select.setActive(false);
		
		return select;
	}// close createSelectDrawInteraction
	
	/**
	 * Ritorna lo strumento di disegno appositamente configurato per permettere la modifica delle geometrie disegnate.
	 * 
	 * @param {@link ol.interaction.Select} select, interaction che gestisce la selezione dei dati vettoriali.
	 * 
	 * Returns:  
	 * 	  {@link ol.interaction.Modify} 
	 */
	this.createModifyInteraction = function (select) {
		
		var modify = new ol.interaction.Modify({
			    /** Identificativo interaction **/
			 	id: appConstants.getParam("ol.ApplicationProperty").ID_INTERACTION_MODIFY_FEATURE,
			 	/**
			 	 * Una funzione che prende un ol.MapBrowserEvent e restituisce un valore booleano che indica se l'evento deve essere gestito. 
			 	 * Per impostazione predefinita, ol.events.condition.singleClick cancella il vertice.
			 	 * (ol.events.condition.singleClick: Return true if no modifier key (alt-, shift- or platform-modifier-key) è premuto.
			 	 */
			 	deleteCondition: function(event) {
			 	    return ol.events.condition.noModifierKeys(event) && ol.events.condition.singleClick(event);
			 	},
			 	/** FeatureOverlay style. **/
	//		 	style:
			 	/** The features the interaction works on. */
			 	features: select.getFeatures()
			});
	
		modify.setId(appConstants.getParam("ol.ApplicationProperty").ID_INTERACTION_MODIFY_FEATURE);
		modify.setActive(false);
		
		return modify;
	}// close createModifyInteraction
	
	/**
	 * Ritorna lo strumento che gestisce la selezione dei dati vettoriali, l'interaction si attiva al "click" sul layer.
	 * 
	 * @param {@link String} id, (Opzionale)
	 * @param {@link ol.layer.Vector} destVector, layer di destinazione se assente l'interaction verrà applicata a tutti i layer aggiunti alla mappa (Opzionale)
	 * @param {@link Boolean} active, true se l'itecation è attiva, false altrimenti.
	 * @param {@link ol.style.Style} style 
	 * 
	 * Returns:  
	 * 	  {@link ol.interaction.Select} 
	 */
	this.createSelectFeatureInteraction = function (id, destVector, active, style) {
		
		/**
		 * Handles selection of vector data. A ol.FeatureOverlay is maintained internally to store the selected feature(s). 
		 * Which features are selected is determined by the condition option, and optionally the toggle or add/remove options.
		 */
		var select = new ol.interaction.Select({
				/** Identificativo interaction **/
			 	id: (angular.isDefined(id) && id != null && !angular.equals(id, "")) ? id : null,
		 		/**
			 	 * A list of layers from which features should be selected. Alternatively, a filter function can be provided. 
			 	 * The function will be called for each layer in the map and should return true for layers that you want to be selectable. 
			 	 * If the option is absent, all visible layers will be considered selectable.
			 	 */
				layers: destVector != null ? [destVector] : null,
				/**
				 * Un valore booleano che determina se il comportamento di default dovrebbe essere la selezione singola delle feature 
				 * o anche più di una. Il valore predefinito è falso i.e select singola.
				 */
				multi: false,
				/**
				 * Una funzione che prende un ol.MapBrowserEvent e restituisce un valore booleano che indica se l'evento deve essere gestito. 
				 * Questo è l'evento da scatenare per la selezione.
				 * Cliccando su una feature la seleziona rimuovendo eventuali altre feature dalla selezione. 
				 * Facendo clic al di fuori di una feature le rimuove tutte dalla selezione.
				 */
				condition: ol.events.condition.singleClick,
				/**
				 * Style for the selected features (those in the FeatureOverlay).
				 */
				style: (angular.isDefined(style) && style != null) ? style : null
			});
		
		/** se l'id è valorizzato correttamente , lo imposto come identificativo dell'interaction **/
		if(angular.isDefined(id) && id != null && !angular.equals(id, "")) select.setId(id);
		
		/** true if the interaction is active, false otherwise. **/
		select.setActive(active);
		
		return select;
	}// close createSelectFeatureInteraction
	
	/**
	 * Ritorna lo strumento che gestisce l'highlights dei dati vettoriali, l'interaction si attiva all'hover delle feature.
	 * 
	 * @param {@link String} id, (Opzionale)
	 * @param {@link ol.layer.Vector} destVector, layer di destinazione se assente l'interaction è applicata a tutti i layer aggiunti alla mappa (Opzionale)
	 * @param {@link Boolean} active, true se l'itecation è attiva, false altrimenti.
	 * @param {@link ol.style.Style} style 
	 * 
	 * Returns:  
	 * 	  {@link ol.interaction.Select} 
	 */
	this.createHighlightsFeatureInteraction = function (id, destVector, active, style) {
		
		/**
		 * Handles selection of vector data. A ol.FeatureOverlay is maintained internally to store the selected feature(s). 
		 * Which features are selected is determined by the condition option, and optionally the toggle or add/remove options.
		 */
		var highlights = new ol.interaction.Select({
				/** Identificativo interaction **/
			 	id: (angular.isDefined(id) && id != null && !angular.equals(id, "")) ? id : null,
		 		/**
			 	 * A list of layers from which features should be selected. Alternatively, a filter function can be provided. 
			 	 * The function will be called for each layer in the map and should return true for layers that you want to be selectable. 
			 	 * If the option is absent, all visible layers will be considered selectable.
			 	 */
				layers: destVector != null ? [destVector] : null,
				/**
				 * Un valore booleano che determina se il comportamento di default dovrebbe essere la selezione singola delle feature 
				 * o anche più di una. Il valore predefinito è falso i.e select singola.
				 */
				multi: false,
				/**
				 * Una funzione che prende un ol.MapBrowserEvent e restituisce un valore booleano che indica se l'evento deve essere gestito. 
				 * Questo è l'evento da scatenare per la selezione.
				 * Cliccando su una feature la seleziona rimuovendo eventuali altre feature dalla selezione. 
				 * Facendo clic al di fuori di una feature le rimuove tutte dalla selezione.
				 */
				condition: ol.events.condition.pointerMove,
				/**
				 * Style for the selected features (those in the FeatureOverlay).
				 */
				style: (angular.isDefined(style) && style != null) ? style : null
			});
		
		/** se l'id è valorizzato correttamente, lo imposto come identificativo dell'interaction **/
		if(angular.isDefined(id) && id != null && !angular.equals(id, "")) highlights.setId(id);
		
		/** true if the interaction is active, false otherwise. **/
		highlights.setActive(active);
		
		/**
		 * Attiva per la "ol.interaction.Select" la gestione del cursore all'hover sulla feature.
		 */
//		highlights.setCursor();
		
		return highlights;
	}// close createHighlightsFeatureInteraction
}]);